package com.zhike.service.im;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.eva.epc.common.util.CommonUtils;
import com.zhike.mobileimsdk.server.protocal.Protocal;
import com.zhike.common.dto.GroupMember4Cache;
import com.zhike.common.dto.GroupMemberEntity;
import com.zhike.common.dto.MsgBody4Group;
import com.zhike.common.dto.MsgBodyRoot;
import com.zhike.common.model.GroupBase;
import com.zhike.service.im.concurrent.GroupSenderConcurrentExecutor;
import com.zhike.service.im.manager.MessageRecordManager;
import com.zhike.service.im.manager.OfflineMessageManager;
import com.zhike.utils.MessageHelper;
import com.zhike.utils.MessageHelper.SendResultObserver;
import com.zhike.utils.cache.GroupsMembersCacheProvider;

import lombok.extern.slf4j.Slf4j;

import com.zhike.utils.manager.UsersStatusManager;

/**
 * IM Server 服务器群聊专用业务逻辑实现类.
 * 
 * @author Jack Jiang(http://www.52im.net/space-uid-1.html)
 * @version 1.0
 */
@Slf4j
@Component
@Deprecated
public class ChatLogicManager4Group {

  @Resource
  private ChatServerEventListener chatServerEventListener;
  @Resource
  private OfflineMessageManager offlineMessageManager;

  @Resource
  private MessageRecordManager messageRecordManager;

  @Autowired
  private GroupsMembersCacheProvider groupsMembersCacheProvider;

  @Resource
  private MessageHelper messageHelper;

  /**
   * 群聊/世界频道消息的代码实现代码。
   * <p>
   * 说明：为了简化普通群聊消息的发送算法，本方法采用的是群消息扩散写的方式，
   * 如有疑问可以参考这篇文章：http://www.52im.net/thread-812-1-1.html
   * 
   * @param dataContent
   */
  public boolean processMT44_OF_GROUP$CHAT$MSG_A$TO$SERVER(final String fingerPrint, final int msgType,
      final String dataContent) {
    final UsersStatusManager liverUsersMgr = chatServerEventListener.getLiverUsersMgr();

    // 将群聊消息的处理和发送放在独立的线程池中处理以提升处理效率，防止在大用户量时阻塞其它服务
    GroupSenderConcurrentExecutor.getInstance().execute(new Runnable() {
      @Override
      public void run() {
        // 解析群组聊天消息
        final MsgBody4Group msgBody = MessageHelper.pareseGroupChatMsg_A$TO$SERVER_Message(dataContent);

        log.debug("[RBChat]【群聊/世界频道】《《《《《！收到了群发消息！》》》》》 ->" + msgBody);

        // 结果正常解析出来了
        if (msgBody != null) {
          String gid = msgBody.getT();
          Iterator membersToSend = null;
          final String logTAG = GroupBase.isWorldChat(gid) ? "世界频道" : "群聊(" + gid + ")";

          // 世界频道（即bbs聊天）直接发给所在在线的人
          // FIXME: 注意：基于性能考虑，世界频道在在规模用户场景下，强烈建议关闭之！
          if (GroupBase.isWorldChat(gid)) {
            Set<String> liveUsers = liverUsersMgr.getLiveUsers().keySet();
            membersToSend = liveUsers.iterator();
          }
          // 普通群聊是发给群内所有成员
          else {
            try {
              // *************** 以下代码是从高速缓存中读取群成员列表，提升性能
              ConcurrentHashMap<String, GroupMember4Cache> members2Vec = groupsMembersCacheProvider.get(gid);
              membersToSend = members2Vec.keySet().iterator();
            } catch (Exception e) {
              log.debug("[RBChat]【" + logTAG + "】" + e.getMessage(), e);
            }
          }

          // 遍历发给所有接收者（本方法的群聊消息采用“扩散写”的方式实现）
          if (membersToSend != null) {
            while (membersToSend.hasNext()) {
              final String k = (String) membersToSend.next();

              // 此消息的发起用户是发送消息者本人（当然不需要转发给自已罗）
              if (k.equals(msgBody.getF())) {
                log.debug("[RBChat]【" + logTAG + "】【无需发给自已END】群员"
                    + k + "就是消息发起人，不需要再由服务端转发该条消息哦.");
              } else {
                // 将聊天消息转发给本次消息接收者
                String liveUserId = k;

                // 目标接收人是否在线？
                final boolean isDestFriendOnline = liverUsersMgr.isOnline(liveUserId);
                // boolean realtimeSucess = false;

                // 普通群聊（非世界频道）
                if (!GroupBase.isWorldChat(gid)) {
                  try {
                    // 指令发送结果观察者（因为通信底层netty是异步通知数据发送结果的）
                    SendResultObserver sendResultObserver = new SendResultObserver() {
                      @Override
                      public void update(boolean code, Protocal p) {
                        // 返回值true：对于应用层逻辑来说，无论是在线发送成功，或者是跨服桥接成功，都算是发送成功
                        if (code) {
                          log.debug("[RBChat]【" + logTAG + "】【投递OK】已成功将uid=" + msgBody.getF()
                              + "的消息实时或桥接发给成员：" + k + ").");

                          // 说明：满足此条件，表示本地不在线但处于与Web互通模式的情况下，消息却发送成功，也需要进行App的push通知，
                          // 因为前提是app端已不在线，进行push是合情合理的（否则桥接成功的情况下，app这边即使不在线也永远收
                          // 不到app的push通知，除非web那端也要实现不在线时的app的push通知。
                          // 备忘：此处的push逻辑是为了省去web那端不在线时的app push通知逻辑，日后支持全功能集群后，就不需
                          // 要这个逻辑了，因为包括web集群实例在内，都将是对等的且必须支持app 的push逻辑——所以没必要以下代码。
                          if (!isDestFriendOnline && ChatServerLauncher.bridgeEnabled) {
                            // 尝试进行app端的push通知
                            offlineMessageManager.processOfflineMessage(p, true); // 注意此参数为true！
                          }

                        }
                        // 返回值false：实时或桥接发送没有成功（需要离线处理）
                        else {
                          log.warn("[RBChat]【" + logTAG + "】【投递NO1】将uid=" + msgBody.getF()
                              + "的消息实时或桥接发给成员：" + k + "失败了，马上考虑是否需要进行离线处理哦。。。");

                          // 将该条聊天消息插入到数据库中（以备下次接收方B上线后拿到）
                          offlineMessageManager.processOfflineMessage(p, false);
                        }
                      }
                    };

                    // （如果用户连在本APPP实例则直发，否则开启与web互通时将桥接发）
                    messageHelper.sendGroupChatMsg_SERVER$TO$B_Message(liveUserId, msgBody, sendResultObserver);
                  } catch (Exception e) {
                    log.warn("[RBChat]【" + logTAG + "】【投递NO2】将uid=" + msgBody.getF()
                        + "的消息实时发给用户" + k + "时出错了，原因是：" + e.getMessage(), e);
                  }
                }
                // 世界频道聊天
                else {
                  // TODO: 备忘-> 因无法目前无全功能集群支持，无法取得所有im接入层的在线列表，所以
                  // 当开通与web端互通时，就无法取得真正的所有在线列表了。不过，世界频道
                  // 仅作为一个产品运营初始为了聚拢人气而做的一个临时性聊天室而已，用处
                  // 不是太多。因而为了保持技术的简洁性，暂时只实现了app端的世界频道哦！

                  // 接收者现在在APP端在线
                  if (isDestFriendOnline) {
                    log.debug("[RBChat]【" + logTAG + "】【在线发送中..】正在将消息转发给" + k + "...");

                    try {
                      // 指令发送结果观察者（因为通信底层netty是异步通知数据发送结果的）
                      SendResultObserver sendResultObserver = new SendResultObserver() {
                        @Override
                        public void update(boolean code, Protocal p) {
                          if (code) {
                            log.debug("[RBChat]【" + logTAG + "】【在线发送OK】已成功将uid=" + msgBody.getF()
                                + "的消息实时发给成员：" + k + ").");
                          } else
                            log.warn("[RBChat]【" + logTAG + "】【在线发送NO1】将uid=" + msgBody.getF()
                                + "的消息实时发给成员：" + k + "失败了！");
                        }
                      };
                      messageHelper.sendGroupChatMsg_SERVER$TO$B_Message(liveUserId, msgBody, sendResultObserver);
                    } catch (Exception e) {
                      log.warn("[RBChat]【" + logTAG + "】【在线发送NO2】将uid=" + msgBody.getF()
                          + "的消息实时发给用户" + k + "时出错了，原因是：" + e.getMessage(), e);
                    }
                  }
                }
              }
            }

            /**
             * 20190328 by Jack Jiang：按照目前的设计原则，为了减化架构和处理的复杂性，服务端主动发起
             * 的S2C类型消息或指令一律由发送者处理（详见设计备忘），切记！
             */
            // ** 【用户消息收集】收集用户的聊天消息，以供后台进行用户行为分析，
            messageRecordManager.colectChattingMsgAsync(gid, dataContent, msgType, fingerPrint);
          } else {
            log.warn("[RBChat]【" + logTAG + "】uid=" + msgBody.getF()
                + "的群聊消息不需要发送，因为接收列表是null (membersToSend=null)！！");
          }
        }
      }
    });

    return true;
  }

  /**
   * 【建群时的批量通知】向被邀请入群的群成员批量发出已成功加群的通知（已支持离线存储）。
   * 
   * @param ownerUid           群创建者uid（相对于其它人来说，就是邀请发起人）
   * @param ownerNickName      群创建者昵称
   * @param beInvitedList      被邀请者列表
   * @param newGroupInfoReturn 本群基本信息（用于实时发送给被邀请人）
   */
  public void batchNotification4CreateGroupAsync(
      final String ownerUid, final String ownerNickName, final ArrayList<GroupMemberEntity> beInvitedList,
      final GroupBase newGroupInfoReturn) {
    batchNotification4InviteMembersAsync(
        "0", "群聊CMD-建群通知", ownerUid, ownerNickName, beInvitedList, null // 建群时没有老群员啊，所以不存在通知老群员的问题
        , newGroupInfoReturn);
  }

  /**
   * 【邀请新人入群时的批量通知】向被邀请入群的群成员批量发出已成功加群的通知、向其它群员
   * 发出新入群成员通知（已支持离线存储）。
   * 
   * @param logTAG
   * @param srcFrom             加群来源，"0"表示通过邀请加群、"1"表示通过扫描二难码加群、"2"表示通过分享的群名片加群，默认可为null（为null将默认是通过邀请加群）
   * @param invitedBeUid        本次邀请发起人或群二维码分享人的uid
   * @param invitedBeNickName   本次邀请发起人或群二维码分享人的昵称
   * @param newJoinedMemberList 被邀请人列表（用于接受通知：你加入成功了）
   * @param oldMemberList       原群员列表（用于接受通知：有人加入群了）
   * @param newGroupInfoReturn  本群基本信息（用于实时发送给被邀请人）
   */
  public void batchNotification4InviteMembersAsync(final String srcFrom, final String logTAG, final String invitedBeUid,
      final String invitedBeNickName, final ArrayList<GroupMemberEntity> newJoinedMemberList,
      final Collection<GroupMember4Cache> oldMemberList, final GroupBase newGroupInfoReturn) {
    // 将群组的系统通知指令处理和发送放在独立的线程池中处理以提升处理效率，防止在大用户量时阻塞其它服务
    GroupSenderConcurrentExecutor.getInstance().execute(new Runnable() {
      @Override
      public void run() {
        try {
          // true表示是通过扫描二维码加群
          boolean fromScanQRCode = "1".equals(srcFrom);
          // true表示是通过群名片加群
          boolean fromGroupContact = "2".equals(srcFrom);
          // 被邀请人昵称
          String newJoinNickNameHuman = null;

          // 通知被邀请者自已：入群成功
          if (newJoinedMemberList != null && newJoinedMemberList.size() > 0) {
            int size = newJoinedMemberList.size();
            if (size > 1)
              newJoinNickNameHuman = newJoinedMemberList.get(0).getNickname() + " 等 " + size + "人";
            else
              newJoinNickNameHuman = newJoinedMemberList.get(0).getNickname();

            for (GroupMemberEntity newJoinedMember : newJoinedMemberList) {
              String newJoinedMemberUid = newJoinedMember.getUserId();

              // 如果是来自2维码扫描加群，就不需要通知加群者自已了
              if (fromScanQRCode || fromGroupContact) {
                //
              }
              // 否则，如果是来自邀请入群，则要通知被邀请的人（但不需要通知邀请者自已）
              else if (!newJoinedMemberUid.equals(invitedBeUid)) {
                // 通知被邀请自已入群成功(这条通知是发给被邀请入群者自已的，所以此处的被邀请者昵称用“你”)
                // messageHelper.sendGroupSysCMD4MyselfBeInvited(newJoinedMemberUid,
                // invitedBeUid,
                // invitedBeNickName, newGroupInfoReturn);
              }
            }
          }

          String defaultNotificationContent = "";
          if (fromScanQRCode) {
            defaultNotificationContent = "\"" + newJoinNickNameHuman + "\"通过扫描\"" + invitedBeNickName + "\"分享的二维码加入群聊";
          } else if (fromGroupContact) {
            defaultNotificationContent = "\"" + newJoinNickNameHuman + "\"通过"
                + (CommonUtils.isStringEmpty(invitedBeNickName, true) ? "" : "\"" + invitedBeNickName + "\"分享的")
                + "群名片加入群聊";
          } else {
            defaultNotificationContent = "\"" + invitedBeNickName + "\"邀请\"" + newJoinNickNameHuman + "\"加入了群聊";
          }

          // 通知老群员：有人入群了
          if (oldMemberList != null && oldMemberList.size() > 0) {
            for (GroupMember4Cache oldMember : oldMemberList) {
              // 是扫码加群时，要通知包括2维码分享人在内的所有老群员
              if (fromScanQRCode || fromGroupContact) {
                String notificationContent = defaultNotificationContent;
                // 如果要通知的老群员正是分享者，则将特殊内容特殊处理
                if (invitedBeUid.equals(oldMember.getUserUid())) {
                  if (fromScanQRCode) {
                    notificationContent = "\"" + newJoinNickNameHuman + "\"通过扫描你分享的二维码加入群聊";// 将2维码分享人的名字显示为“你“
                  } else {
                    notificationContent = "\"" + newJoinNickNameHuman + "\"通过你分享的群名片加入群聊";// 将群名片分享人的名字显示为“你“
                  }
                }
                // messageHelper.sendGroupSysCMD4CommonInfo(oldMember.getUserUid(),
                // notificationContent,
                // newGroupInfoReturn.getGId());
              } else {
                // 不是扫码加群时，邀请发起人自已就不需要通知了（客户端会自已在界面里插入提示信息）
                if (!invitedBeUid.equals(oldMember.getUserUid())) {
                  // messageHelper.sendGroupSysCMD4CommonInfo(oldMember.getUserUid(),
                  // defaultNotificationContent,
                  // newGroupInfoReturn.getGId());
                }
              }
            }
          }

          /**
           * 20190328 by Jack
           * Jiang：按照目前的设计原则，为了减化架构和处理的复杂性，服务端主动发起的S2C类型消息或指令一律由发送者处理（详见设计备忘），切记！
           */
          // ** 【用户消息收集】收集用户的聊天消息，以供后台进行用户行为分析
          // ** 注意：群聊消息的消息记录是由发方处理的，否则扩散写后再处理，要存储的消息条数就多了，从而浪费存储资源（详见备忘录说明）
          messageRecordManager.colectMsgAsync("",
              // 群指令通知因是服务端主动发出，所以消息记录里“发出人”填“0”
              "0", newGroupInfoReturn.getGroupId(), MsgBodyRoot.CHAT_TYPE_GROUP$CHAT, MsgBodyRoot.TYPE_SYSTEAM$INFO
          // 存入聊天记录里的群通知内容（当前主要用于web端查询聊天记录时使用）
              , defaultNotificationContent
          // 此指纹码没有任何其它作用，作用为落库后以及其它使用时去重使用
              , Protocal.genFingerPrint());
        } catch (Exception e) {
          log.debug("[RBChat]【" + logTAG + "】" + e.getMessage(), e);
        }
      }
    });
  }

  /**
   * 【通用群聊系统消息的批量通知】向指定的群员列表发送通用系统通知（已支持离线存储）。
   * 
   * @param logTAG
   * @param systemInfo 要发送的文字内容
   * @param memberList 要发送的群员列表
   * @param gid        该群id
   *                   // * @param gname 该群群名
   * @param excludeUid 要跳过不发送的uid
   */
  public void batchNotification4CommonInfoAsync(final String logTAG, final String systemInfo,
      final Collection<GroupMember4Cache> memberList, final String gid, final String excludeUid) {
    // 将群组的系统通知指令处理和发送放在独立的线程池中处理以提升处理效率，防止在大用户量时阻塞其它服务
    GroupSenderConcurrentExecutor.getInstance().execute(new Runnable() {
      @Override
      public void run() {
        try {
          // 通知老群员：有人入群了
          if (memberList != null && memberList.size() > 0) {
            for (GroupMember4Cache oldMember : memberList) {
              if (excludeUid == null || !oldMember.getUserUid().equals(excludeUid)) {
                // messageHelper.sendGroupSysCMD4CommonInfo(oldMember.getUserUid(), systemInfo,
                // gid);
              }
            }
          }

          // ** 【用户消息收集】收集用户的聊天消息，以供后台进行用户行为分析
          // ** 注意：群聊消息的消息记录是由发方处理的，否则扩散写后再处理，
          // ** 要存储的消息条数就多了，从而浪费存储资源（详见备忘录说明）
          messageRecordManager.colectMsgAsync("",
              // 群指令通知因是服务端主动发出，所以消息记录里“发出人”填“0”
              "0", gid, MsgBodyRoot.CHAT_TYPE_GROUP$CHAT, MsgBodyRoot.TYPE_SYSTEAM$INFO
          // 存入聊天记录里的群通知内容（当前主要用于web端查询聊天记录时使用）
              , systemInfo, Protocal.genFingerPrint() // 此指纹码没有任何其它作用，作用为落库后以及其它使用时去重使用
          );
        } catch (Exception e) {
          log.debug("[RBChat]【" + logTAG + "】" + e.getMessage(), e);
        }
      }
    });
  }

  /**
   * 【群被解散的批量通知】向除群主外的所有群员发送此系统通知（已支持离线存储）。
   * 
   * @param logTAG
   * @param memberList 要发送的群员列表
   * @param gid        该群id
   *                   // * @param gname 该群群名
   * @param excludeUid 要跳过不发送的uid
   */
  public void batchNotification4GroupDismissedAsync(final String logTAG, final Collection<GroupMember4Cache> memberList,
      final String gid, final String excludeUid, final String dismissUserName) {
    // 将群组的系统通知指令处理和发送放在独立的线程池中处理以提升处理效率，防止在大用户量时阻塞其它服务
    GroupSenderConcurrentExecutor.getInstance().execute(new Runnable() {
      @Override
      public void run() {
        try {
          // 发出通知
          if (memberList != null && memberList.size() > 0) {
            for (GroupMember4Cache oldMember : memberList) {
              if (excludeUid == null || !oldMember.getUserUid().equals(excludeUid)) {
                // messageHelper.sendGroupSysCMD4Dismissed(oldMember.getUserUid(),
                // dismissUserName, gid);
              }
            }
          }

          /**
           * 20190328 by Jack Jiang：按照目前的设计原则，为了减化架构和处理的复杂性，服务端主动发起
           * 的S2C类型消息或指令一律由发送者处理（详见设计备忘），切记！
           */
          // ** 【用户消息收集】收集用户的聊天消息，以供后台进行用户行为分析
          // ** 注意：群聊消息的消息记录是由发方处理的，否则扩散写后再处理，
          // ** 要存储的消息条数就多了，从而浪费存储资源（详见备忘录说明）
          messageRecordManager.colectMsgAsync("",
              // 群指令通知因是服务端主动发出，所以消息记录里“发出人”填“0”
              "0", gid, MsgBodyRoot.CHAT_TYPE_GROUP$CHAT, MsgBodyRoot.TYPE_SYSTEAM$INFO
          // 存入聊天记录里的群通知内容（当前主要用于web端查询聊天记录时使用）
              , "本群已被\"" + dismissUserName + "\"解散", Protocal.genFingerPrint() // 此指纹码没有任何其它作用，作用为落库后以及其它使用时去重使用
          );
        } catch (Exception e) {
          log.debug("[RBChat]【" + logTAG + "】" + e.getMessage(), e);
        }
      }
    });
  }

  /**
   * 【有人退群或被群主踢出时的批量通知】向被踢者发出通知、向其它群员发出通知（已支持离线存储）。
   * 
   * @param logTAG
   * @param removedOprUid       本次删除的操作人uid（群主踢人时本参数为群主，如果是用户自已退出退路时本参数为退出者自已）
   * @param removedOprNickName  本次删除的操作人昵称
   * @param beRemovedMemberList 被删除的人列表（用于接受通知）
   * @param oldMemberList       原群员列表（用于接受通知：有人被删除了）
   */
  public void batchNotification4SomeoneBeRemovedAsync(final String logTAG, final String removedOprUid,
      final String removedOprNickName, final ArrayList<GroupMemberEntity> beRemovedMemberList,
      final Collection<GroupMember4Cache> oldMemberList, final String gid) {
    // 将群组的系统通知指令处理和发送放在独立的线程池中处理以提升处理效率，防止在大用户量时阻塞其它服务
    GroupSenderConcurrentExecutor.getInstance().execute(new Runnable() {
      @Override
      public void run() {
        try {
          String someoneBeRemovedNickNameHuman = null;

          // 是否是自已退出群组的（因为自已退出跟群主删除，是用的同一个接口，所以到底
          // 是不是自已退出，需要通过下面的代码来判断一下）
          boolean himselfQuitGroup = false;

          int size = beRemovedMemberList.size();
          // 通知被删除者
          if (beRemovedMemberList != null && size > 0) {
            if (size > 1)
              someoneBeRemovedNickNameHuman = beRemovedMemberList.get(0).getNickname() + " 等 " + size + "人";
            else
              someoneBeRemovedNickNameHuman = beRemovedMemberList.get(0).getNickname();

            // 如果删除列表中只有一个人，且是删除操作者自已，那它就是自已退出群了
            if (size == 1 && beRemovedMemberList.get(0).getUserId().equals(removedOprUid))
              himselfQuitGroup = true;

            for (GroupMemberEntity beRemovedMember : beRemovedMemberList) {
              String beRemovedMemberUid = beRemovedMember.getUserId();

              // 自已退群的
              if (himselfQuitGroup) {
                log.debug("[RBChat]【" + logTAG + "】用户"
                    + removedOprNickName + "(" + removedOprUid + ")是自已退群的，本条通知不需要" + "通知它自已了！");
              }
              // 被群主踢出群聊（由Server发出，被踢者接收）
              else {
                // 通知被删除者
                // messageHelper.sendGroupSysCMD4YouBeRemoved(beRemovedMemberUid,
                // removedOprNickName, gid);
              }
            }
          }

          // 通知老群员：有人主动退出或被群主踢出群聊了（TODO: 微信里这个是不通知的，为了性能，以后也可以不通知！）
          if (oldMemberList != null && oldMemberList.size() > 0) {
            for (GroupMember4Cache oldMember : oldMemberList) {
              // 不需要通知删除操作者自已
              if (!removedOprUid.equals(oldMember.getUserUid())) {
                // messageHelper.sendGroupSysCMD4SomeoneRemoved(himselfQuitGroup,
                // oldMember.getUserUid(),
                // removedOprNickName, someoneBeRemovedNickNameHuman, gid);
              }
            }
          }

          // ** 【用户消息收集】收集用户的聊天消息，以供后台进行用户行为分析
          // ** 注意：群聊消息的消息记录是由发方处理的，否则扩散写后再处理，
          // ** 要存储的消息条数就多了，从而浪费存储资源（详见备忘录说明）
          String infoToRecord = "";
          if (himselfQuitGroup)
            infoToRecord = "\"" + someoneBeRemovedNickNameHuman + "\"已退出本群";
          else
            infoToRecord = "\"" + someoneBeRemovedNickNameHuman + "\"已被\"" + removedOprNickName + "\"移出本群";

          /**
           * 20190328 by Jack Jiang：按照目前的设计原则，为了减化架构和处理的复杂性，服务端主动发起
           * 的S2C类型消息或指令一律由发送者处理（详见设计备忘），切记！
           */
          messageRecordManager.colectMsgAsync("",
              // 群指令通知因是服务端主动发出，所以消息记录里“发出人”填“0”
              "0", gid, MsgBodyRoot.CHAT_TYPE_GROUP$CHAT, MsgBodyRoot.TYPE_SYSTEAM$INFO
          // 存入聊天记录里的群通知内容（当前主要用于web端查询聊天记录时使用）
              , infoToRecord, Protocal.genFingerPrint() // 此指纹码没有任何其它作用，作用为落库后以及其它使用时去重使用
          );
        } catch (Exception e) {
          log.debug("[RBChat]【" + logTAG + "】" + e.getMessage(), e);
        }
      }
    });
  }

  /**
   * 【群名被改的批量通知】群名被修改的系统通知（由Server发出，所有除修改者外的群员接收）（已支持离线存储）。
   * 
   * @param logTAG
   */
  public void batchNotification4GroupNameChangedAsync(final String logTAG, final String changedByUid,
      final String changedByNickName, final String newGroupName, final Collection<GroupMember4Cache> memberList,
      final String gid) {
    // 将群组的系统通知指令处理和发送放在独立的线程池中处理以提升处理效率，防止在大用户量时阻塞其它服务
    GroupSenderConcurrentExecutor.getInstance().execute(new Runnable() {
      @Override
      public void run() {
        try {
          // 通知群员
          if (memberList != null && memberList.size() > 0) {
            for (GroupMember4Cache oldMember : memberList) {
              // 修改者自已就不需要通知了
              if (changedByUid == null || !oldMember.getUserUid().equals(changedByUid)) {
                // MessageHelper.sendGroupSysCMD4CommonInfo(
                // oldMember.getUser_uid(), systemInfo, gid, gname);
                // messageHelper.sendGroupSysCMD4GroupNameChanged(
                // oldMember.getUserUid(), changedByUid, changedByNickName, newGroupName, gid);
              }
            }
          }

          /**
           * 20190328 by Jack Jiang：按照目前的设计原则，为了减化架构和处理的复杂性，服务端主动发起
           * 的S2C类型消息或指令一律由发送者处理（详见设计备忘），切记！
           */
          messageRecordManager.colectMsgAsync("",
              // 群指令通知因是服务端主动发出，所以消息记录里“发出人”填“0”
              "0", gid, MsgBodyRoot.CHAT_TYPE_GROUP$CHAT, MsgBodyRoot.TYPE_SYSTEAM$INFO
          // 存入聊天记录里的群通知内容（当前主要用于web端查询聊天记录时使用）
              , "\"" + changedByNickName + "\"修改群名为\"" + newGroupName + "\"", Protocal.genFingerPrint() // 此指纹码没有任何其它作用，作用为落库后以及其它使用时去重使用
          );
        } catch (Exception e) {
          log.debug("[RBChat]【" + logTAG + "】" + e.getMessage(), e);
        }
      }
    });
  }
}
